import json

import requests
from fastapi import Depends
from loguru import logger
from sqlalchemy.orm import Session
from sqlalchemy import text
import time
from Util.EncoderUtil import encode, decode, getAuthToken
from config.Database import get_db
from schemas.ClockRecord import ClockRecordRequest
from models.UserInfoModel import UserInfo


class UserServe:



    @staticmethod
    async def save_user_info(token: str,db: Session = Depends(get_db)):
        allUserInfo = await UserServe.get_user_info(token)
        if not allUserInfo:
            logger.error(f'获取用户信息失败')
            return None
        allUserInfo['personTag'] = json.dumps(allUserInfo.get('personTag', []), ensure_ascii=False)
        by_id = await UserServe.get_user_info_by_id(db, allUserInfo.get('id'))
        if not by_id:
            newUserInfo = await UserServe.create_user_info(db, allUserInfo)
            logger.info(f"用户信息: {newUserInfo.name} 已创建")
            return newUserInfo
        else:
            logger.info(f"用户信息: {by_id.name} 已存在")
            return by_id
        

    @staticmethod
    async def get_user_info(token: str):
        try:
            # 发起请求
            response = requests.get(
                "https://ekta.jjvu.jx.cn/api/app/client/v1/student/user/my-person-info",
                headers={"Authorization": encode(getAuthToken(token))}
            )
            # 解密响应
            decrypted_string = decode(response.text)
            if not decrypted_string:
                raise Exception("get_user_info 解密结果为空字符串")

            # 解析JSON
            decrypted_json = json.loads(decrypted_string)

            return decrypted_json["data"]

        except Exception as e:
            print(f"get_user_info 函数内部错误: {e}")
            return None
        pass

    @staticmethod
    async def getUserHistory(clockRecord: ClockRecordRequest):
        params = f'{{"userId": "{clockRecord.userId}", "activityId": {clockRecord.activityId}}}'
        try:
            # 发起请求
            response = requests.post(
                "https://ekta.jjvu.jx.cn/api/app/client/v1/activity/sign/one/list",
                params={"params": encode(params)},
                headers={"Authorization": encode(getAuthToken(clockRecord.token))}
            )
            # 解密响应
            decrypted_string = decode(response.text)
            if not decrypted_string:
                raise Exception("getUserHistory 解密结果为空字符串")
            # 解析JSON
            decrypted_json = json.loads(decrypted_string)
            # 转为 Activity 对象数组
            return decrypted_json
        except Exception as e:
            logger.error(f"getUserHistory 函数内部错误: {e}")
            return None
        pass
    
    # 新增用户信息
    @staticmethod
    async def create_user_info(db: Session, user_info: dict):
        """
        创建新用户信息
        :param db: 数据库会话
        :param user_info: 用户信息字典
        :return: 创建的用户信息对象
        """
        try:
            # 创建用户信息对象
            new_user = UserInfo(**user_info)
            # 添加到数据库
            db.add(new_user)
            # 提交事务
            db.commit()
            # 刷新对象以获取数据库生成的值
            db.refresh(new_user)
            return new_user
        except Exception as e:
            # 发生错误时回滚事务
            db.rollback()
            logger.error(f"create_user_info 函数内部错误: {e}")
            return None
    
    # 获取单个用户信息
    @staticmethod
    async def get_user_info_by_id(db: Session, user_id: int):
        """
        根据ID获取用户信息
        :param db: 数据库会话
        :param user_id: 用户ID
        :return: 用户信息对象
        """
        try:
            return db.query(UserInfo).filter(UserInfo.id == user_id).first()
        except Exception as e:
            logger.error(f"get_user_info_by_id 函数内部错误: {e}")
            return None
    
    # 根据学号获取用户信息
    @staticmethod
    async def get_user_info_by_code(db: Session, code: str):
        """
        根据学号获取用户信息
        :param db: 数据库会话
        :param code: 学号
        :return: 用户信息对象
        """
        try:
            return db.query(UserInfo).filter(UserInfo.code == code).first()
        except Exception as e:
            logger.error(f"get_user_info_by_code 函数内部错误: {e}")
            return None
    
    # 获取用户列表
    @staticmethod
    async def get_user_list(db: Session, skip: int = 0, limit: int = 100):
        """
        获取用户列表
        :param db: 数据库会话
        :param skip: 跳过记录数
        :param limit: 限制返回记录数
        :return: 用户列表
        """
        try:
            return db.query(UserInfo).offset(skip).limit(limit).all()
        except Exception as e:
            logger.error(f"get_user_list 函数内部错误: {e}")
            return []
    
    # 更新用户信息
    @staticmethod
    async def update_user_info(db: Session, user_id: int, user_info: dict):
        """
        更新用户信息
        :param db: 数据库会话
        :param user_id: 用户ID
        :param user_info: 更新的用户信息字典
        :return: 更新后的用户信息对象
        """
        try:
            # 查询用户
            user = db.query(UserInfo).filter(UserInfo.id == user_id).first()
            if not user:
                return None
            
            # 更新用户信息
            for key, value in user_info.items():
                if hasattr(user, key):
                    setattr(user, key, value)
            
            # 提交事务
            db.commit()
            # 刷新对象
            db.refresh(user)
            return user
        except Exception as e:
            # 发生错误时回滚事务
            db.rollback()
            logger.error(f"update_user_info 函数内部错误: {e}")
            return None
    
    # 删除用户信息
    @staticmethod
    async def delete_user_info(db: Session, user_id: int):
        """
        删除用户信息
        :param db: 数据库会话
        :param user_id: 用户ID
        :return: 是否删除成功
        """
        try:
            # 查询用户
            user = db.query(UserInfo).filter(UserInfo.id == user_id).first()
            if not user:
                return False
            
            # 删除用户
            db.delete(user)
            # 提交事务
            db.commit()
            return True
        except Exception as e:
            # 发生错误时回滚事务
            db.rollback()
            logger.error(f"delete_user_info 函数内部错误: {e}")
            return False
    
    # 根据条件查询用户
    @staticmethod
    async def search_users(db: Session, search_params: dict, skip: int = 0, limit: int = 100):
        """
        根据条件查询用户
        :param db: 数据库会话
        :param search_params: 查询条件字典
        :param skip: 跳过记录数
        :param limit: 限制返回记录数
        :return: 符合条件的用户列表
        """
        try:
            query = db.query(UserInfo)
            
            # 添加查询条件
            for key, value in search_params.items():
                if hasattr(UserInfo, key) and value is not None:
                    query = query.filter(getattr(UserInfo, key) == value)
            
            # 执行查询
            return query.offset(skip).limit(limit).all()
        except Exception as e:
            logger.error(f"search_users 函数内部错误: {e}")
            return []
    
    # 批量导入用户信息
    @staticmethod
    async def batch_import_users(db: Session, users_data: list):
        """
        批量导入用户信息
        :param db: 数据库会话
        :param users_data: 用户信息列表
        :return: 成功导入的用户数量
        """
        try:
            # 创建用户对象列表
            users = [UserInfo(**user_data) for user_data in users_data]
            # 批量添加
            db.add_all(users)
            # 提交事务
            db.commit()
            return len(users)
        except Exception as e:
            # 发生错误时回滚事务
            db.rollback()
            logger.error(f"batch_import_users 函数内部错误: {e}")
            return 0
    
    # 执行原生SQL查询
    @staticmethod
    async def execute_raw_query(db: Session, sql_query: str, params: dict = None):
        """
        执行原生SQL查询
        :param db: 数据库会话
        :param sql_query: SQL查询语句
        :param params: 查询参数
        :return: 查询结果
        """
        try:
            result = db.execute(text(sql_query), params or {})
            return result.fetchall()
        except Exception as e:
            logger.error(f"execute_raw_query 函数内部错误: {e}")
            return []

